python数据类型（一）

发表于 | 更新于 | 分类于

python的数值类型对象

整数

  • 与数学中的整数含义相同，可正可负，内存容量内无限取值范围

  • 整数包括二进制、八进制、十进制、十六进制4种形式。如：0b1010 = 0o12 = 10 = 0xa

  • 整数之间可以进行位运算，位运算只针对整数有作用

    位运算按照二进制方式逐位进行

    | 位运算符 | 描述 |
    | ——– | ——————– |
    | x & y | 按位与 |
    | x | y | 按位或 |
    | ~x | 按位取反 |
    | x ^ y | 按位异或 |
    | x << n | 左移，相当于乘2的n次 |
    | x >> n | 右移 |

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    In [1]: 101&99
    Out[1]: 97

    In [2]: bin(101)
    Out[2]: '0b1100101'

    In [3]: bin(99)
    Out[3]: '0b1100011'

    In [4]: ~101
    Out[4]: -102

    补码=原码取反+1

浮点数

  • 与数学中的实数含义相同，

  • 存在取值范围：+-10^308左右，有精度限制，epsilon，【sys.float_info】。超出一定范围就直接表示为inf（无限大）。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import sys
    print(sys.float_info)

    '''
    sys.float_info(
    max=1.7976931348623157e+308,
    max_exp=1024,
    max_10_exp=308,
    min=2.2250738585072014e-308,
    min_exp=-1021,
    min_10_exp=-307,
    dig=15,
    mant_dig=53,
    epsilon=2.220446049250313e-16,
    radix=2,
    rounds=1)
    '''

  • 浮点数包括常规方法和科学计数法2种方式表示。如：0.0043 = 4.3e-3

  • 不确定尾数问题

    浮点数在计算机中表示不精确

    1
    2
    3
    4
    >>> 0.1+0.2
    0.30000000000000004
    >>> 0.1+0.2 ==0.3
    False

    0.1 在内存中的表示：0.00011001100110011001100110011001100110011001100110011010 (二进制)，转换成十进制是：0.1000000000000000055511151231257827021181583404541015625 (十进制)

    不确定尾数一般发生在10 -16 左右，使用round()辅助浮点数运算，消除不确定尾数

    round(x, d)：对x四舍五入，d是小数截取位数

    1
    2
    >>> round(0.1 + 0.2, 1) == 0.3
    True

  • 大精确浮点运算

    python整数运算是精确的。可以将浮点数转换成（数值整数，小数位数整数）二元组，用二元组进行计算。这样就能把浮点数运算转换成整数运算。

    例如：1.2e-3 + 0.01–>(12,4)+(1,2)–>(12,4)+(100,4)–>(112,4)–>0.0112

复数

  • 与数学中的复数概念相同，定义
    $$
    j =\sqrt{2}
    $$

    复数表示为
    $$
    s = a+bj
    $$

  • z = a+bj，a是实部，b是虚部，a和b都是浮点数

  • z.real获得z的实部a，z.imag获得z的虚部b

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
>>>type(1+2j)
<class 'complex'>
>>>complex(123)
(123+0j)

z = 12+34.5j
>>>z.imag
34.5
>>>z.real
12.0
>>>type(z.imag)
<class 'float'>
>>>type(z.real)
<class 'float'>

>>>1+2j == 1.0+2.0J
True

>>>12+34.5j+6+7.8j
(18+42.3j)
>>>(1+2j)*10
(10+20j)
>>>(1+2j)**2
(-3+4j)
>>>z=12+34.5j
>>>y=1+2j
>>>print(y*z)
(-57+58.5j)

数值运算

  • 操作符

    | 操作符 | 描述 |
    | —— | ———- |
    | x+y | 加 |
    | x-y | 减 |
    | xy | 乘 |
    | x/y | 除 |
    | x//y | 整数除 |
    | x%y | 求余，取模 |
    | +x | 数字本身 |
    | -y | 取负 |
    | x**y | 幂运算 |
    | += | |
    | -= | |
    |     = | |
    | /= | |
    | //= | |
    | %= | |
    | **= | |

    类型间可进行混合运算，生成结果为”最宽”类型

    三种类型存在一种逐渐”扩展”或”变宽”的关系：
    整数 -> 浮点数 -> 复数
    例如：123 + 4.0 = 127.0 (整数+浮点数 = 浮点数)

  • 函数

    python解释器提供的内置函数

    | 函数及使用 | 描述 |
    | ——————– | ———————————— |
    | abs(x) | 返回绝对值 |
    | divmod(x, y) | 返回商余元组 （x//y, x%y） |
    | pow(x, y[, z]) | 幂余，（x**y）%z ，z缺省为1 |
    | round(x [, d]) | 四舍五入，d是保留小数位数，缺省值为0 |
    | max(x1 ,x2, …, xn) | 返回最大值 |
    | min(x1, x2, …, xn) | 返回最小值 |

    | 函数及使用 | 描述 |
    | ———- | ———————————————– |
    | int(x) | x变成整数，舍弃小数部分。不写x时，创建整数对象0 |
    | ord(ch) | 单个字符转换成Unicode码编码整数 |
    | float(x) | x变成浮点数，增加小数部分 |
    | complex(x) | 将x变成复数，增加虚数部分 |

  • 方法

    数值类型在python解释器内部都是类（class），类的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
>>>1+10
11
>>>1+0xa
11
>>>1+0b1010
11
>>>1+0o12
11
>>>1010 // 11
91
>>>1010 / 11
91.81818181818181
>>>1010 % 11
9
>>> 9 / 3
3.0
>>>pow(2, 10)
1024
>>>2**10
1024
>>>pow(2, 0.5)
1.4142135623730951
>>>abs(-1010)
1010
>>>print(a, b)
1054 30
>>>a, b = b, a

>>>str(a)
‘30’
>>>bin(a)
'0b11110'
>>>oct(a)
'0o36'
>>>hex(a)
'0x1e'
>>>a += 1
>>>print(a)
31
>>>a **= 2
>>>print(a)
961
>>>max(a, b, 10, 20, 100, 200)
1054


>>>10 + 12.3
22.3
>>>0xa + 0b1010
20
>>>int(1.99)
1
>>>round(1.99)
2
>>>float(10)
10.0
>>>complex(10)
(10+0j)
>>>type((10+0j).real)
<class 'float'>
>>>(1+2j)*0
0j
>>>1.23*0
0.0
>>>1024*0
0

>>>12.3 + 98.7
111.0
>>>1.23e1 + 9.87e1
111.0
>>>type(12.3)
<class 'float'>
>>>type(123)
<class 'int'>
>>>str(12.3)
'12.3'
>>>float(123)
123.0
>>>float("12.3")
12.3
>>>a = 101
>>>b = 1.0
>>>print(a*b)
101.0
>>>12.3*0.1
1.2300000000000002
>>>round(12.3*0.1, 2)
1.23
>>>0.1 + 0.2
0.30000000000000004
>>>round(0.1 + 0.2, 1)
0.3
>>>0.1 + 0.2 == 0.3
False
>>>round(0.1 + 0.2, 1) == 0.3
True
>>>"{:.2f}".format(1234.56789)
'1234.57'
>>>"{:.1f}".format(1234.56789)
'1234.6'
>>>"{:.10f}".format(1234.56789)
'1234.5678900000'
>>>"{:,.1f}".format(1234.56789)
'1,234.6'
>>>print("{:,.1f}".format(1234.56789))
1,234.6
>>>"{:.1e}".format(1234.56789)
'1.2e+03'
>>>min(1.23, 4.56, 1, 1.1)
1
>>>max(1.23, 4.56)
4.56
>>>pow(1.23, 4.56)
2.5702023016193025
>>>abs(3+4j)
5.0
>>>str(3+4j)
'(3+4j)'
>>>hex(123)
'0x7b'
>>>a = 2**10
>>>b = 1 + 2j
>>>a, b = b, a
>>>print(a, b)
(1+2j) 1024
>>>a += b
>>>print(a, b)
(1025+2j) 1024
>>>a *= 0
>>>print(a)
0j
>>>int(a)
Traceback (most recent call last):
  File "<pyshell#127>", line 1, in <module>
    int(a)
TypeError: can't convert complex to int
>>>int(a.imag)
0
>>>max(1, 1.0, 0.4)
1
>>>max(1.0, 1, 0.4)
1.0
>>>min(1, 1.0, 1j)
Traceback (most recent call last):
  File "<pyshell#132>", line 1, in <module>
    min(1, 1.0, 1j)
TypeError: unorderable types: complex() < int()
>>>type(100//11)
<class 'int'>
>>>type(100/11)
<class 'float'>
>>>type(100 % 2.0) == type(1)
False
>>>len(str(999**99))
297
>>>a = 0xa + 0b1010 + 12.34
>>>b = int(11.99)
>>>print(a, b)
32.34 11
>>>a, b = b, a
>>>print(a, b)
11 32.34
>>>a = -a
>>>b = complex(b)
>>>print(a, b)
-11 (32.34+0j)
>>>a + b
(21.340000000000003+0j)
>>>a + b == 21.34 + 0j
False
>>>a + b == 21.340000000000003
True
>>>round((a+b).real, 2) == 21.34
True
>>>hex(425)
'0x1a9'
>>>max(0x1a9, 425, 400)
425
>>>425/125
3.4